home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus 2000 #4 / Amiga Plus CD - 2000 - No. 4.iso / PowerPC / Dev / PPCRelease / Examples / PPCInlines / ppc_pragma.h < prev    next >
Encoding:
C/C++ Source or Header  |  1998-08-04  |  31.6 KB  |  1,132 lines
  1. /* Automatically generated header! Do not edit! */
  2.  
  3. #ifndef _PPCPRAGMA_PPC_H
  4. #define _PPCPRAGMA_PPC_H
  5. #ifdef __GNUC__
  6. #ifndef _PPCINLINE__PPC_H
  7. #include <powerup/ppcinline/ppc.h>
  8. #endif
  9. #else
  10.  
  11. #ifndef POWERUP_PPCLIB_INTERFACE_H
  12. #include <powerup/ppclib/interface.h>
  13. #endif
  14.  
  15. #ifndef POWERUP_GCCLIB_PROTOS_H
  16. #include <powerup/gcclib/powerup_protos.h>
  17. #endif
  18.  
  19. #ifndef NO_PPCINLINE_STDARG
  20. #define NO_PPCINLINE_STDARG
  21. #endif/* SAS C PPC inlines */
  22.  
  23. #ifndef PPC_BASE_NAME
  24. #define PPC_BASE_NAME PPCLibBase
  25. #endif /* !PPC_BASE_NAME */
  26.  
  27. #define    PPCAddPortList(PPCPortList, PPCPort)    _PPCAddPortList(PPC_BASE_NAME, PPCPortList, PPCPort)
  28.  
  29. static __inline BOOL
  30. _PPCAddPortList(void *PPCLibBase, void*PPCPortList, void*PPCPort)
  31. {
  32. struct Caos    MyCaos;
  33.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  34. //    MyCaos.M68kStart    =    NULL;
  35. //    MyCaos.M68kSize        =    0;
  36.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  37. //    MyCaos.PPCStart        =    NULL;
  38. //    MyCaos.PPCSize        =    0;
  39.     MyCaos.a0        =(ULONG) PPCPortList;
  40.     MyCaos.a1        =(ULONG) PPCPort;
  41.     MyCaos.caos_Un.Offset    =    (-378);
  42.     MyCaos.a6        =(ULONG) PPCLibBase;    
  43.     return((BOOL)PPCCallOS(&MyCaos));
  44. }
  45.  
  46. #define    PPCAllocMem(size, attributes)    _PPCAllocMem(PPC_BASE_NAME, size, attributes)
  47.  
  48. static __inline void*
  49. _PPCAllocMem(void *PPCLibBase, ULONG size, ULONG attributes)
  50. {
  51. struct Caos    MyCaos;
  52.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  53. //    MyCaos.M68kStart    =    NULL;
  54. //    MyCaos.M68kSize        =    0;
  55.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  56. //    MyCaos.PPCStart        =    NULL;
  57. //    MyCaos.PPCSize        =    0;
  58.     MyCaos.d0        =(ULONG) size;
  59.     MyCaos.d1        =(ULONG) attributes;
  60.     MyCaos.caos_Un.Offset    =    (-48);
  61.     MyCaos.a6        =(ULONG) PPCLibBase;    
  62.     return((void*)PPCCallOS(&MyCaos));
  63. }
  64.  
  65. #define    PPCAllocPooled(poolHeader, memSize)    _PPCAllocPooled(PPC_BASE_NAME, poolHeader, memSize)
  66.  
  67. static __inline void*
  68. _PPCAllocPooled(void *PPCLibBase, void*poolHeader, ULONG memSize)
  69. {
  70. struct Caos    MyCaos;
  71.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  72. //    MyCaos.M68kStart    =    NULL;
  73. //    MyCaos.M68kSize        =    0;
  74.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  75. //    MyCaos.PPCStart        =    NULL;
  76. //    MyCaos.PPCSize        =    0;
  77.     MyCaos.a0        =(ULONG) poolHeader;
  78.     MyCaos.d0        =(ULONG) memSize;
  79.     MyCaos.caos_Un.Offset    =    (-246);
  80.     MyCaos.a6        =(ULONG) PPCLibBase;    
  81.     return((void*)PPCCallOS(&MyCaos));
  82. }
  83.  
  84. #define    PPCAllocVec(byteSize, attributes)    _PPCAllocVec(PPC_BASE_NAME, byteSize, attributes)
  85.  
  86. static __inline void*
  87. _PPCAllocVec(void *PPCLibBase, ULONG byteSize, ULONG attributes)
  88. {
  89. struct Caos    MyCaos;
  90.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  91. //    MyCaos.M68kStart    =    NULL;
  92. //    MyCaos.M68kSize        =    0;
  93.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  94. //    MyCaos.PPCStart        =    NULL;
  95. //    MyCaos.PPCSize        =    0;
  96.     MyCaos.d0        =(ULONG) byteSize;
  97.     MyCaos.d1        =(ULONG) attributes;
  98.     MyCaos.caos_Un.Offset    =    (-60);
  99.     MyCaos.a6        =(ULONG) PPCLibBase;    
  100.     return((void*)PPCCallOS(&MyCaos));
  101. }
  102.  
  103. #define    PPCAllocVecPooled(Pool, byteSize)    _PPCAllocVecPooled(PPC_BASE_NAME, Pool, byteSize)
  104.  
  105. static __inline void*
  106. _PPCAllocVecPooled(void *PPCLibBase, void*Pool, ULONG byteSize)
  107. {
  108. struct Caos    MyCaos;
  109.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  110. //    MyCaos.M68kStart    =    NULL;
  111. //    MyCaos.M68kSize        =    0;
  112.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  113. //    MyCaos.PPCStart        =    NULL;
  114. //    MyCaos.PPCSize        =    0;
  115.     MyCaos.a0        =(ULONG) Pool;
  116.     MyCaos.d0        =(ULONG) byteSize;
  117.     MyCaos.caos_Un.Offset    =    (-258);
  118.     MyCaos.a6        =(ULONG) PPCLibBase;    
  119.     return((void*)PPCCallOS(&MyCaos));
  120. }
  121.  
  122. #define    PPCCacheClearE(address, length, caches)    _PPCCacheClearE(PPC_BASE_NAME, address, length, caches)
  123.  
  124. static __inline void
  125. _PPCCacheClearE(void *PPCLibBase, void*address, ULONG length, ULONG caches)
  126. {
  127. struct Caos    MyCaos;
  128.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  129. //    MyCaos.M68kStart    =    NULL;
  130. //    MyCaos.M68kSize        =    0;
  131.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  132. //    MyCaos.PPCStart        =    NULL;
  133. //    MyCaos.PPCSize        =    0;
  134.     MyCaos.a0        =(ULONG) address;
  135.     MyCaos.d0        =(ULONG) length;
  136.     MyCaos.d1        =(ULONG) caches;
  137.     MyCaos.caos_Un.Offset    =    (-342);
  138.     MyCaos.a6        =(ULONG) PPCLibBase;    
  139.     PPCCallOS(&MyCaos);
  140. }
  141.  
  142. #define    PPCCacheInvalidE(address, length, caches)    _PPCCacheInvalidE(PPC_BASE_NAME, address, length, caches)
  143.  
  144. static __inline void
  145. _PPCCacheInvalidE(void *PPCLibBase, void*address, ULONG length, ULONG caches)
  146. {
  147. struct Caos    MyCaos;
  148.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  149. //    MyCaos.M68kStart    =    NULL;
  150. //    MyCaos.M68kSize        =    0;
  151.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  152. //    MyCaos.PPCStart        =    NULL;
  153. //    MyCaos.PPCSize        =    0;
  154.     MyCaos.a0        =(ULONG) address;
  155.     MyCaos.d0        =(ULONG) length;
  156.     MyCaos.d1        =(ULONG) caches;
  157.     MyCaos.caos_Un.Offset    =    (-348);
  158.     MyCaos.a6        =(ULONG) PPCLibBase;    
  159.     PPCCallOS(&MyCaos);
  160. }
  161.  
  162. #define    PPCCacheTrashE(address, length, caches)    _PPCCacheTrashE(PPC_BASE_NAME, address, length, caches)
  163.  
  164. static __inline void
  165. _PPCCacheTrashE(void *PPCLibBase, void*address, ULONG length, ULONG caches)
  166. {
  167. struct Caos    MyCaos;
  168.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  169. //    MyCaos.M68kStart    =    NULL;
  170. //    MyCaos.M68kSize        =    0;
  171.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  172. //    MyCaos.PPCStart        =    NULL;
  173. //    MyCaos.PPCSize        =    0;
  174.     MyCaos.a0        =(ULONG) address;
  175.     MyCaos.d0        =(ULONG) length;
  176.     MyCaos.d1        =(ULONG) caches;
  177.     MyCaos.caos_Un.Offset    =    (-432);
  178.     MyCaos.a6        =(ULONG) PPCLibBase;    
  179.     PPCCallOS(&MyCaos);
  180. }
  181.  
  182. #define    PPCCreateMessage(PPCPort, Length)    _PPCCreateMessage(PPC_BASE_NAME, PPCPort, Length)
  183.  
  184. static __inline void*
  185. _PPCCreateMessage(void *PPCLibBase, void*PPCPort, ULONG Length)
  186. {
  187. struct Caos    MyCaos;
  188.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  189. //    MyCaos.M68kStart    =    NULL;
  190. //    MyCaos.M68kSize        =    0;
  191.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  192. //    MyCaos.PPCStart        =    NULL;
  193. //    MyCaos.PPCSize        =    0;
  194.     MyCaos.a0        =(ULONG) PPCPort;
  195.     MyCaos.d0        =(ULONG) Length;
  196.     MyCaos.caos_Un.Offset    =    (-294);
  197.     MyCaos.a6        =(ULONG) PPCLibBase;    
  198.     return((void*)PPCCallOS(&MyCaos));
  199. }
  200.  
  201. #define    PPCCreatePool(memFlags, puddleSize, threshSize)    _PPCCreatePool(PPC_BASE_NAME, memFlags, puddleSize, threshSize)
  202.  
  203. static __inline void*
  204. _PPCCreatePool(void *PPCLibBase, ULONG memFlags, ULONG puddleSize, ULONG threshSize)
  205. {
  206. struct Caos    MyCaos;
  207.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  208. //    MyCaos.M68kStart    =    NULL;
  209. //    MyCaos.M68kSize        =    0;
  210.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  211. //    MyCaos.PPCStart        =    NULL;
  212. //    MyCaos.PPCSize        =    0;
  213.     MyCaos.d0        =(ULONG) memFlags;
  214.     MyCaos.d1        =(ULONG) puddleSize;
  215.     MyCaos.d2        =(ULONG) threshSize;
  216.     MyCaos.caos_Un.Offset    =    (-234);
  217.     MyCaos.a6        =(ULONG) PPCLibBase;    
  218.     return((void*)PPCCallOS(&MyCaos));
  219. }
  220.  
  221. #define    PPCCreatePort(Tags)    _PPCCreatePort(PPC_BASE_NAME, Tags)
  222.  
  223. static __inline void*
  224. _PPCCreatePort(void *PPCLibBase, struct TagItem*Tags)
  225. {
  226. struct Caos    MyCaos;
  227.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  228. //    MyCaos.M68kStart    =    NULL;
  229. //    MyCaos.M68kSize        =    0;
  230.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  231. //    MyCaos.PPCStart        =    NULL;
  232. //    MyCaos.PPCSize        =    0;
  233.     MyCaos.a0        =(ULONG) Tags;
  234.     MyCaos.caos_Un.Offset    =    (-270);
  235.     MyCaos.a6        =(ULONG) PPCLibBase;    
  236.     return((void*)PPCCallOS(&MyCaos));
  237. }
  238.  
  239. #ifndef NO_PPCINLINE_STDARG
  240. #define PPCCreatePortTags(tags...) \
  241.     ({ULONG _tags[] = { tags }; PPCCreatePort((struct TagItem*)_tags);})
  242. #endif /* !NO_PPCINLINE_STDARG */
  243.  
  244. #define    PPCCreatePortList(PPCPortArray, ExtSignals)    _PPCCreatePortList(PPC_BASE_NAME, PPCPortArray, ExtSignals)
  245.  
  246. static __inline void*
  247. _PPCCreatePortList(void *PPCLibBase, void**PPCPortArray, ULONG ExtSignals)
  248. {
  249. struct Caos    MyCaos;
  250.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  251. //    MyCaos.M68kStart    =    NULL;
  252. //    MyCaos.M68kSize        =    0;
  253.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  254. //    MyCaos.PPCStart        =    NULL;
  255. //    MyCaos.PPCSize        =    0;
  256.     MyCaos.a0        =(ULONG) PPCPortArray;
  257.     MyCaos.d0        =(ULONG) ExtSignals;
  258.     MyCaos.caos_Un.Offset    =    (-366);
  259.     MyCaos.a6        =(ULONG) PPCLibBase;    
  260.     return((void*)PPCCallOS(&MyCaos));
  261. }
  262.  
  263. #define    PPCCreateTask(ElfObject, Tags)    _PPCCreateTask(PPC_BASE_NAME, ElfObject, Tags)
  264.  
  265. static __inline void    *
  266. _PPCCreateTask(void *PPCLibBase, void*ElfObject, struct TagItem*Tags)
  267. {
  268. struct Caos    MyCaos;
  269.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  270. //    MyCaos.M68kStart    =    NULL;
  271. //    MyCaos.M68kSize        =    0;
  272.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  273. //    MyCaos.PPCStart        =    NULL;
  274. //    MyCaos.PPCSize        =    0;
  275.     MyCaos.a0        =(ULONG) ElfObject;
  276.     MyCaos.a1        =(ULONG) Tags;
  277.     MyCaos.caos_Un.Offset    =    (-84);
  278.     MyCaos.a6        =(ULONG) PPCLibBase;    
  279.     return((void    *)PPCCallOS(&MyCaos));
  280. }
  281.  
  282. #ifndef NO_PPCINLINE_STDARG
  283. #define PPCCreateTaskTags(a0, tags...) \
  284.     ({ULONG _tags[] = { tags }; PPCCreateTask((a0), (struct TagItem*)_tags);})
  285. #endif /* !NO_PPCINLINE_STDARG */
  286.  
  287. #define    PPCDeleteMessage(PPCMessage)    _PPCDeleteMessage(PPC_BASE_NAME, PPCMessage)
  288.  
  289. static __inline void
  290. _PPCDeleteMessage(void *PPCLibBase, void*PPCMessage)
  291. {
  292. struct Caos    MyCaos;
  293.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  294. //    MyCaos.M68kStart    =    NULL;
  295. //    MyCaos.M68kSize        =    0;
  296.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  297. //    MyCaos.PPCStart        =    NULL;
  298. //    MyCaos.PPCSize        =    0;
  299.     MyCaos.a0        =(ULONG) PPCMessage;
  300.     MyCaos.caos_Un.Offset    =    (-300);
  301.     MyCaos.a6        =(ULONG) PPCLibBase;    
  302.     PPCCallOS(&MyCaos);
  303. }
  304.  
  305. #define    PPCDeletePool(poolHeader)    _PPCDeletePool(PPC_BASE_NAME, poolHeader)
  306.  
  307. static __inline BOOL
  308. _PPCDeletePool(void *PPCLibBase, void*poolHeader)
  309. {
  310. struct Caos    MyCaos;
  311.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  312. //    MyCaos.M68kStart    =    NULL;
  313. //    MyCaos.M68kSize        =    0;
  314.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  315. //    MyCaos.PPCStart        =    NULL;
  316. //    MyCaos.PPCSize        =    0;
  317.     MyCaos.a0        =(ULONG) poolHeader;
  318.     MyCaos.caos_Un.Offset    =    (-240);
  319.     MyCaos.a6        =(ULONG) PPCLibBase;    
  320.     return((BOOL)PPCCallOS(&MyCaos));
  321. }
  322.  
  323. #define    PPCDeletePort(PPCPort)    _PPCDeletePort(PPC_BASE_NAME, PPCPort)
  324.  
  325. static __inline BOOL
  326. _PPCDeletePort(void *PPCLibBase, void*PPCPort)
  327. {
  328. struct Caos    MyCaos;
  329.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  330. //    MyCaos.M68kStart    =    NULL;
  331. //    MyCaos.M68kSize        =    0;
  332.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  333. //    MyCaos.PPCStart        =    NULL;
  334. //    MyCaos.PPCSize        =    0;
  335.     MyCaos.a0        =(ULONG) PPCPort;
  336.     MyCaos.caos_Un.Offset    =    (-276);
  337.     MyCaos.a6        =(ULONG) PPCLibBase;    
  338.     return((BOOL)PPCCallOS(&MyCaos));
  339. }
  340.  
  341. #define    PPCDeletePortList(PPCPortList)    _PPCDeletePortList(PPC_BASE_NAME, PPCPortList)
  342.  
  343. static __inline void
  344. _PPCDeletePortList(void *PPCLibBase, void*PPCPortList)
  345. {
  346. struct Caos    MyCaos;
  347.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  348. //    MyCaos.M68kStart    =    NULL;
  349. //    MyCaos.M68kSize        =    0;
  350.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  351. //    MyCaos.PPCStart        =    NULL;
  352. //    MyCaos.PPCSize        =    0;
  353.     MyCaos.a0        =(ULONG) PPCPortList;
  354.     MyCaos.caos_Un.Offset    =    (-372);
  355.     MyCaos.a6        =(ULONG) PPCLibBase;    
  356.     PPCCallOS(&MyCaos);
  357. }
  358.  
  359. #define    PPCDeleteTask(TaskObject)    _PPCDeleteTask(PPC_BASE_NAME, TaskObject)
  360.  
  361. static __inline BOOL
  362. _PPCDeleteTask(void *PPCLibBase, void*TaskObject)
  363. {
  364. struct Caos    MyCaos;
  365.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  366. //    MyCaos.M68kStart    =    NULL;
  367. //    MyCaos.M68kSize        =    0;
  368.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  369. //    MyCaos.PPCStart        =    NULL;
  370. //    MyCaos.PPCSize        =    0;
  371.     MyCaos.a0        =(ULONG) TaskObject;
  372.     MyCaos.caos_Un.Offset    =    (-90);
  373.     MyCaos.a6        =(ULONG) PPCLibBase;    
  374.     return((BOOL)PPCCallOS(&MyCaos));
  375. }
  376.  
  377. #define    PPCFindTask(Name)    _PPCFindTask(PPC_BASE_NAME, Name)
  378.  
  379. static __inline void    *
  380. _PPCFindTask(void *PPCLibBase, char    *Name)
  381. {
  382. struct Caos    MyCaos;
  383.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  384. //    MyCaos.M68kStart    =    NULL;
  385. //    MyCaos.M68kSize        =    0;
  386.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  387. //    MyCaos.PPCStart        =    NULL;
  388. //    MyCaos.PPCSize        =    0;
  389.     MyCaos.a0        =(ULONG) Name;
  390.     MyCaos.caos_Un.Offset    =    (-102);
  391.     MyCaos.a6        =(ULONG) PPCLibBase;    
  392.     return((void    *)PPCCallOS(&MyCaos));
  393. }
  394.  
  395. #define    PPCFindTaskObject(TaskObject)    _PPCFindTaskObject(PPC_BASE_NAME, TaskObject)
  396.  
  397. static __inline void    *
  398. _PPCFindTaskObject(void *PPCLibBase, void*TaskObject)
  399. {
  400. struct Caos    MyCaos;
  401.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  402. //    MyCaos.M68kStart    =    NULL;
  403. //    MyCaos.M68kSize        =    0;
  404.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  405. //    MyCaos.PPCStart        =    NULL;
  406. //    MyCaos.PPCSize        =    0;
  407.     MyCaos.a0        =(ULONG) TaskObject;
  408.     MyCaos.caos_Un.Offset    =    (-144);
  409.     MyCaos.a6        =(ULONG) PPCLibBase;    
  410.     return((void    *)PPCCallOS(&MyCaos));
  411. }
  412.  
  413. #define    PPCFreeMem(Memory, size)    _PPCFreeMem(PPC_BASE_NAME, Memory, size)
  414.  
  415. static __inline void
  416. _PPCFreeMem(void *PPCLibBase, void*Memory, ULONG size)
  417. {
  418. struct Caos    MyCaos;
  419.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  420. //    MyCaos.M68kStart    =    NULL;
  421. //    MyCaos.M68kSize        =    0;
  422.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  423. //    MyCaos.PPCStart        =    NULL;
  424. //    MyCaos.PPCSize        =    0;
  425.     MyCaos.a1        =(ULONG) Memory;
  426.     MyCaos.d0        =(ULONG) size;
  427.     MyCaos.caos_Un.Offset    =    (-54);
  428.     MyCaos.a6        =(ULONG) PPCLibBase;    
  429.     PPCCallOS(&MyCaos);
  430. }
  431.  
  432. #define    PPCFreePooled(poolHeader, memory, memSize)    _PPCFreePooled(PPC_BASE_NAME, poolHeader, memory, memSize)
  433.  
  434. static __inline void
  435. _PPCFreePooled(void *PPCLibBase, void*poolHeader, APTR memory, ULONG memSize)
  436. {
  437. struct Caos    MyCaos;
  438.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  439. //    MyCaos.M68kStart    =    NULL;
  440. //    MyCaos.M68kSize        =    0;
  441.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  442. //    MyCaos.PPCStart        =    NULL;
  443. //    MyCaos.PPCSize        =    0;
  444.     MyCaos.a0        =(ULONG) poolHeader;
  445.     MyCaos.a1        =(ULONG) memory;
  446.     MyCaos.d0        =(ULONG) memSize;
  447.     MyCaos.caos_Un.Offset    =    (-252);
  448.     MyCaos.a6        =(ULONG) PPCLibBase;    
  449.     PPCCallOS(&MyCaos);
  450. }
  451.  
  452. #define    PPCFreeVec(memoryBlock)    _PPCFreeVec(PPC_BASE_NAME, memoryBlock)
  453.  
  454. static __inline void*
  455. _PPCFreeVec(void *PPCLibBase, void*memoryBlock)
  456. {
  457. struct Caos    MyCaos;
  458.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  459. //    MyCaos.M68kStart    =    NULL;
  460. //    MyCaos.M68kSize        =    0;
  461.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  462. //    MyCaos.PPCStart        =    NULL;
  463. //    MyCaos.PPCSize        =    0;
  464.     MyCaos.a1        =(ULONG) memoryBlock;
  465.     MyCaos.caos_Un.Offset    =    (-66);
  466.     MyCaos.a6        =(ULONG) PPCLibBase;    
  467.     return((void*)PPCCallOS(&MyCaos));
  468. }
  469.  
  470. #define    PPCFreeVecPooled(Pool, memoryBlock)    _PPCFreeVecPooled(PPC_BASE_NAME, Pool, memoryBlock)
  471.  
  472. static __inline void
  473. _PPCFreeVecPooled(void *PPCLibBase, void*Pool, void*memoryBlock)
  474. {
  475. struct Caos    MyCaos;
  476.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  477. //    MyCaos.M68kStart    =    NULL;
  478. //    MyCaos.M68kSize        =    0;
  479.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  480. //    MyCaos.PPCStart        =    NULL;
  481. //    MyCaos.PPCSize        =    0;
  482.     MyCaos.a0        =(ULONG) Pool;
  483.     MyCaos.a1        =(ULONG) memoryBlock;
  484.     MyCaos.caos_Un.Offset    =    (-264);
  485.     MyCaos.a6        =(ULONG) PPCLibBase;    
  486.     PPCCallOS(&MyCaos);
  487. }
  488.  
  489. #define    PPCGetAttrs(Tags)    _PPCGetAttrs(PPC_BASE_NAME, Tags)
  490.  
  491. static __inline ULONG
  492. _PPCGetAttrs(void *PPCLibBase, struct TagItem*Tags)
  493. {
  494. struct Caos    MyCaos;
  495.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  496. //    MyCaos.M68kStart    =    NULL;
  497. //    MyCaos.M68kSize        =    0;
  498.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  499. //    MyCaos.PPCStart        =    NULL;
  500. //    MyCaos.PPCSize        =    0;
  501.     MyCaos.a0        =(ULONG) Tags;
  502.     MyCaos.caos_Un.Offset    =    (-138);
  503.     MyCaos.a6        =(ULONG) PPCLibBase;    
  504.     return((ULONG)PPCCallOS(&MyCaos));
  505. }
  506.  
  507. #ifndef NO_PPCINLINE_STDARG
  508. #define PPCGetAttrsTags(tags...) \
  509.     ({ULONG _tags[] = { tags }; PPCGetAttrs((struct TagItem*)_tags);})
  510. #endif /* !NO_PPCINLINE_STDARG */
  511.  
  512. #define    PPCGetMessage(PPCPort)    _PPCGetMessage(PPC_BASE_NAME, PPCPort)
  513.  
  514. static __inline void*
  515. _PPCGetMessage(void *PPCLibBase, void*PPCPort)
  516. {
  517. struct Caos    MyCaos;
  518.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  519. //    MyCaos.M68kStart    =    NULL;
  520. //    MyCaos.M68kSize        =    0;
  521.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  522. //    MyCaos.PPCStart        =    NULL;
  523. //    MyCaos.PPCSize        =    0;
  524.     MyCaos.a0        =(ULONG) PPCPort;
  525.     MyCaos.caos_Un.Offset    =    (-312);
  526.     MyCaos.a6        =(ULONG) PPCLibBase;    
  527.     return((void*)PPCCallOS(&MyCaos));
  528. }
  529.  
  530. #define    PPCGetMessageAttr(PPCMessage, Attr)    _PPCGetMessageAttr(PPC_BASE_NAME, PPCMessage, Attr)
  531.  
  532. static __inline ULONG
  533. _PPCGetMessageAttr(void *PPCLibBase, void*PPCMessage, ULONG Attr)
  534. {
  535. struct Caos    MyCaos;
  536.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  537. //    MyCaos.M68kStart    =    NULL;
  538. //    MyCaos.M68kSize        =    0;
  539.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  540. //    MyCaos.PPCStart        =    NULL;
  541. //    MyCaos.PPCSize        =    0;
  542.     MyCaos.a0        =(ULONG) PPCMessage;
  543.     MyCaos.d0        =(ULONG) Attr;
  544.     MyCaos.caos_Un.Offset    =    (-306);
  545.     MyCaos.a6        =(ULONG) PPCLibBase;    
  546.     return((ULONG)PPCCallOS(&MyCaos));
  547. }
  548.  
  549. #define    PPCGetObjectAttrs(ElfObject, PPCObjectInfo, Tags)    _PPCGetObjectAttrs(PPC_BASE_NAME, ElfObject, PPCObjectInfo, Tags)
  550.  
  551. static __inline ULONG
  552. _PPCGetObjectAttrs(void *PPCLibBase, void*ElfObject, struct PPCObjectInfo*PPCObjectInfo, struct TagItem*Tags)
  553. {
  554. struct Caos    MyCaos;
  555.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  556. //    MyCaos.M68kStart    =    NULL;
  557. //    MyCaos.M68kSize        =    0;
  558.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  559. //    MyCaos.PPCStart        =    NULL;
  560. //    MyCaos.PPCSize        =    0;
  561.     MyCaos.a0        =(ULONG) ElfObject;
  562.     MyCaos.a1        =(ULONG) PPCObjectInfo;
  563.     MyCaos.a2        =(ULONG) Tags;
  564.     MyCaos.caos_Un.Offset    =    (-198);
  565.     MyCaos.a6        =(ULONG) PPCLibBase;    
  566.     return((ULONG)PPCCallOS(&MyCaos));
  567. }
  568.  
  569. #ifndef NO_PPCINLINE_STDARG
  570. #define PPCGetObjectAttrsTags(a0, a1, tags...) \
  571.     ({ULONG _tags[] = { tags }; PPCGetObjectAttrs((a0), (a1), (struct TagItem*)_tags);})
  572. #endif /* !NO_PPCINLINE_STDARG */
  573.  
  574. #define    PPCGetPortListAttr(PPCPortList, Attr)    _PPCGetPortListAttr(PPC_BASE_NAME, PPCPortList, Attr)
  575.  
  576. static __inline ULONG
  577. _PPCGetPortListAttr(void *PPCLibBase, void*PPCPortList, ULONG Attr)
  578. {
  579. struct Caos    MyCaos;
  580.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  581. //    MyCaos.M68kStart    =    NULL;
  582. //    MyCaos.M68kSize        =    0;
  583.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  584. //    MyCaos.PPCStart        =    NULL;
  585. //    MyCaos.PPCSize        =    0;
  586.     MyCaos.a0        =(ULONG) PPCPortList;
  587.     MyCaos.d0        =(ULONG) Attr;
  588.     MyCaos.caos_Un.Offset    =    (-396);
  589.     MyCaos.a6        =(ULONG) PPCLibBase;    
  590.     return((ULONG)PPCCallOS(&MyCaos));
  591. }
  592.  
  593. #define    PPCGetTaskAttrs(TaskObject, Tags)    _PPCGetTaskAttrs(PPC_BASE_NAME, TaskObject, Tags)
  594.  
  595. static __inline ULONG
  596. _PPCGetTaskAttrs(void *PPCLibBase, void*TaskObject, struct TagItem*Tags)
  597. {
  598. struct Caos    MyCaos;
  599.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  600. //    MyCaos.M68kStart    =    NULL;
  601. //    MyCaos.M68kSize        =    0;
  602.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  603. //    MyCaos.PPCStart        =    NULL;
  604. //    MyCaos.PPCSize        =    0;
  605.     MyCaos.a0        =(ULONG) TaskObject;
  606.     MyCaos.a1        =(ULONG) Tags;
  607.     MyCaos.caos_Un.Offset    =    (-132);
  608.     MyCaos.a6        =(ULONG) PPCLibBase;    
  609.     return((ULONG)PPCCallOS(&MyCaos));
  610. }
  611.  
  612. #ifndef NO_PPCINLINE_STDARG
  613. #define PPCGetTaskAttrsTags(a0, tags...) \
  614.     ({ULONG _tags[] = { tags }; PPCGetTaskAttrs((a0), (struct TagItem*)_tags);})
  615. #endif /* !NO_PPCINLINE_STDARG */
  616.  
  617. #define    PPCLoadObject(Name)    _PPCLoadObject(PPC_BASE_NAME, Name)
  618.  
  619. static __inline APTR
  620. _PPCLoadObject(void *PPCLibBase, char*Name)
  621. {
  622. struct Caos    MyCaos;
  623.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  624. //    MyCaos.M68kStart    =    NULL;
  625. //    MyCaos.M68kSize        =    0;
  626.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  627. //    MyCaos.PPCStart        =    NULL;
  628. //    MyCaos.PPCSize        =    0;
  629.     MyCaos.a0        =(ULONG) Name;
  630.     MyCaos.caos_Un.Offset    =    (-30);
  631.     MyCaos.a6        =(ULONG) PPCLibBase;    
  632.     return((APTR)PPCCallOS(&MyCaos));
  633. }
  634.  
  635. #define    PPCLoadObjectTagList(Tags)    _PPCLoadObjectTagList(PPC_BASE_NAME, Tags)
  636.  
  637. static __inline APTR
  638. _PPCLoadObjectTagList(void *PPCLibBase, struct TagItem*Tags)
  639. {
  640. struct Caos    MyCaos;
  641.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  642. //    MyCaos.M68kStart    =    NULL;
  643. //    MyCaos.M68kSize        =    0;
  644.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  645. //    MyCaos.PPCStart        =    NULL;
  646. //    MyCaos.PPCSize        =    0;
  647.     MyCaos.a0        =(ULONG) Tags;
  648.     MyCaos.caos_Un.Offset    =    (-408);
  649.     MyCaos.a6        =(ULONG) PPCLibBase;    
  650.     return((APTR)PPCCallOS(&MyCaos));
  651. }
  652.  
  653. #ifndef NO_PPCINLINE_STDARG
  654. #define PPCLoadObjectTags(tags...) \
  655.     ({ULONG _tags[] = { tags }; PPCLoadObjectTagList((struct TagItem*)_tags);})
  656. #endif /* !NO_PPCINLINE_STDARG */
  657.  
  658. #define    PPCObtainPort(Tags)    _PPCObtainPort(PPC_BASE_NAME, Tags)
  659.  
  660. static __inline void*
  661. _PPCObtainPort(void *PPCLibBase, struct TagItem*Tags)
  662. {
  663. struct Caos    MyCaos;
  664.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  665. //    MyCaos.M68kStart    =    NULL;
  666. //    MyCaos.M68kSize        =    0;
  667.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  668. //    MyCaos.PPCStart        =    NULL;
  669. //    MyCaos.PPCSize        =    0;
  670.     MyCaos.a0        =(ULONG) Tags;
  671.     MyCaos.caos_Un.Offset    =    (-282);
  672.     MyCaos.a6        =(ULONG) PPCLibBase;    
  673.     return((void*)PPCCallOS(&MyCaos));
  674. }
  675.  
  676. #ifndef NO_PPCINLINE_STDARG
  677. #define PPCObtainPortTags(tags...) \
  678.     ({ULONG _tags[] = { tags }; PPCObtainPort((struct TagItem*)_tags);})
  679. #endif /* !NO_PPCINLINE_STDARG */
  680.  
  681. #define    PPCReadByte(Address)    _PPCReadByte(PPC_BASE_NAME, Address)
  682.  
  683. static __inline UBYTE
  684. _PPCReadByte(void *PPCLibBase, UBYTE*Address)
  685. {
  686. struct Caos    MyCaos;
  687.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  688. //    MyCaos.M68kStart    =    NULL;
  689. //    MyCaos.M68kSize        =    0;
  690.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  691. //    MyCaos.PPCStart        =    NULL;
  692. //    MyCaos.PPCSize        =    0;
  693.     MyCaos.a0        =(ULONG) Address;
  694.     MyCaos.caos_Un.Offset    =    (-222);
  695.     MyCaos.a6        =(ULONG) PPCLibBase;    
  696.     return((UBYTE)PPCCallOS(&MyCaos));
  697. }
  698.  
  699. #define    PPCReadLong(Address)    _PPCReadLong(PPC_BASE_NAME, Address)
  700.  
  701. static __inline ULONG
  702. _PPCReadLong(void *PPCLibBase, ULONG*Address)
  703. {
  704. struct Caos    MyCaos;
  705.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  706. //    MyCaos.M68kStart    =    NULL;
  707. //    MyCaos.M68kSize        =    0;
  708.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  709. //    MyCaos.PPCStart        =    NULL;
  710. //    MyCaos.PPCSize        =    0;
  711.     MyCaos.a0        =(ULONG) Address;
  712.     MyCaos.caos_Un.Offset    =    (-156);
  713.     MyCaos.a6        =(ULONG) PPCLibBase;    
  714.     return((ULONG)PPCCallOS(&MyCaos));
  715. }
  716.  
  717. #define    PPCReadWord(Address)    _PPCReadWord(PPC_BASE_NAME, Address)
  718.  
  719. static __inline UWORD
  720. _PPCReadWord(void *PPCLibBase, UWORD*Address)
  721. {
  722. struct Caos    MyCaos;
  723.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  724. //    MyCaos.M68kStart    =    NULL;
  725. //    MyCaos.M68kSize        =    0;
  726.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  727. //    MyCaos.PPCStart        =    NULL;
  728. //    MyCaos.PPCSize        =    0;
  729.     MyCaos.a0        =(ULONG) Address;
  730.     MyCaos.caos_Un.Offset    =    (-210);
  731.     MyCaos.a6        =(ULONG) PPCLibBase;    
  732.     return((UWORD)PPCCallOS(&MyCaos));
  733. }
  734.  
  735. #define    PPCReleasePort(PPCPort)    _PPCReleasePort(PPC_BASE_NAME, PPCPort)
  736.  
  737. static __inline BOOL
  738. _PPCReleasePort(void *PPCLibBase, void*PPCPort)
  739. {
  740. struct Caos    MyCaos;
  741.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  742. //    MyCaos.M68kStart    =    NULL;
  743. //    MyCaos.M68kSize        =    0;
  744.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  745. //    MyCaos.PPCStart        =    NULL;
  746. //    MyCaos.PPCSize        =    0;
  747.     MyCaos.a0        =(ULONG) PPCPort;
  748.     MyCaos.caos_Un.Offset    =    (-288);
  749.     MyCaos.a6        =(ULONG) PPCLibBase;    
  750.     return((BOOL)PPCCallOS(&MyCaos));
  751. }
  752.  
  753. #define    PPCRemPortList(PPCPortList, PPCPort)    _PPCRemPortList(PPC_BASE_NAME, PPCPortList, PPCPort)
  754.  
  755. static __inline void
  756. _PPCRemPortList(void *PPCLibBase, void*PPCPortList, void*PPCPort)
  757. {
  758. struct Caos    MyCaos;
  759.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  760. //    MyCaos.M68kStart    =    NULL;
  761. //    MyCaos.M68kSize        =    0;
  762.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  763. //    MyCaos.PPCStart        =    NULL;
  764. //    MyCaos.PPCSize        =    0;
  765.     MyCaos.a0        =(ULONG) PPCPortList;
  766.     MyCaos.a1        =(ULONG) PPCPort;
  767.     MyCaos.caos_Un.Offset    =    (-384);
  768.     MyCaos.a6        =(ULONG) PPCLibBase;    
  769.     PPCCallOS(&MyCaos);
  770. }
  771.  
  772. #define    PPCReplyMessage(PPCMessage)    _PPCReplyMessage(PPC_BASE_NAME, PPCMessage)
  773.  
  774. static __inline BOOL
  775. _PPCReplyMessage(void *PPCLibBase, void*PPCMessage)
  776. {
  777. struct Caos    MyCaos;
  778.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  779. //    MyCaos.M68kStart    =    NULL;
  780. //    MyCaos.M68kSize        =    0;
  781.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  782. //    MyCaos.PPCStart        =    NULL;
  783. //    MyCaos.PPCSize        =    0;
  784.     MyCaos.a0        =(ULONG) PPCMessage;
  785.     MyCaos.caos_Un.Offset    =    (-324);
  786.     MyCaos.a6        =(ULONG) PPCLibBase;    
  787.     return((BOOL)PPCCallOS(&MyCaos));
  788. }
  789.  
  790. #define    PPCRunKernelObject(a, b)    _PPCRunKernelObject(PPC_BASE_NAME, a, b)
  791.  
  792. static __inline ULONG
  793. _PPCRunKernelObject(void *PPCLibBase, void*a, struct ModuleArgs*b)
  794. {
  795. struct Caos    MyCaos;
  796.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  797. //    MyCaos.M68kStart    =    NULL;
  798. //    MyCaos.M68kSize        =    0;
  799.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  800. //    MyCaos.PPCStart        =    NULL;
  801. //    MyCaos.PPCSize        =    0;
  802.     MyCaos.a0        =(ULONG) a;
  803.     MyCaos.a1        =(ULONG) b;
  804.     MyCaos.caos_Un.Offset    =    (-114);
  805.     MyCaos.a6        =(ULONG) PPCLibBase;    
  806.     return((ULONG)PPCCallOS(&MyCaos));
  807. }
  808.  
  809. #define    PPCRunKernelObjectFPU()    _PPCRunKernelObjectFPU(PPC_BASE_NAME)
  810.  
  811. static __inline DOUBLE
  812. _PPCRunKernelObjectFPU(void *PPCLibBase)
  813. {
  814. struct Caos    MyCaos;
  815.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  816. //    MyCaos.M68kStart    =    NULL;
  817. //    MyCaos.M68kSize        =    0;
  818.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  819. //    MyCaos.PPCStart        =    NULL;
  820. //    MyCaos.PPCSize        =    0;
  821.     MyCaos.caos_Un.Offset    =    (-150);
  822.     MyCaos.a6        =(ULONG) PPCLibBase;    
  823.     return((DOUBLE)PPCCallOS(&MyCaos));
  824. }
  825.  
  826. #define    PPCRunObject(ElfObject, Argument)    _PPCRunObject(PPC_BASE_NAME, ElfObject, Argument)
  827.  
  828. static __inline ULONG
  829. _PPCRunObject(void *PPCLibBase, void*ElfObject, void*Argument)
  830. {
  831. struct Caos    MyCaos;
  832.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  833. //    MyCaos.M68kStart    =    NULL;
  834. //    MyCaos.M68kSize        =    0;
  835.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  836. //    MyCaos.PPCStart        =    NULL;
  837. //    MyCaos.PPCSize        =    0;
  838.     MyCaos.a0        =(ULONG) ElfObject;
  839.     MyCaos.a1        =(ULONG) Argument;
  840.     MyCaos.caos_Un.Offset    =    (-42);
  841.     MyCaos.a6        =(ULONG) PPCLibBase;    
  842.     return((ULONG)PPCCallOS(&MyCaos));
  843. }
  844.  
  845. #define    PPCSendMessage(PPCPort, PPCMessage, Data, Length, MsgID)    _PPCSendMessage(PPC_BASE_NAME, PPCPort, PPCMessage, Data, Length, MsgID)
  846.  
  847. static __inline BOOL
  848. _PPCSendMessage(void *PPCLibBase, void*PPCPort, void*PPCMessage, void*Data, ULONG Length, ULONG MsgID)
  849. {
  850. struct Caos    MyCaos;
  851.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  852. //    MyCaos.M68kStart    =    NULL;
  853. //    MyCaos.M68kSize        =    0;
  854.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  855. //    MyCaos.PPCStart        =    NULL;
  856. //    MyCaos.PPCSize        =    0;
  857.     MyCaos.a0        =(ULONG) PPCPort;
  858.     MyCaos.a1        =(ULONG) PPCMessage;
  859.     MyCaos.a2        =(ULONG) Data;
  860.     MyCaos.d0        =(ULONG) Length;
  861.     MyCaos.d1        =(ULONG) MsgID;
  862.     MyCaos.caos_Un.Offset    =    (-330);
  863.     MyCaos.a6        =(ULONG) PPCLibBase;    
  864.     return((BOOL)PPCCallOS(&MyCaos));
  865. }
  866.  
  867. #define    PPCSetAttrs(Tags)    _PPCSetAttrs(PPC_BASE_NAME, Tags)
  868.  
  869. static __inline BOOL
  870. _PPCSetAttrs(void *PPCLibBase, struct TagItem*Tags)
  871. {
  872. struct Caos    MyCaos;
  873.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  874. //    MyCaos.M68kStart    =    NULL;
  875. //    MyCaos.M68kSize        =    0;
  876.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  877. //    MyCaos.PPCStart        =    NULL;
  878. //    MyCaos.PPCSize        =    0;
  879.     MyCaos.a0        =(ULONG) Tags;
  880.     MyCaos.caos_Un.Offset    =    (-414);
  881.     MyCaos.a6        =(ULONG) PPCLibBase;    
  882.     return((BOOL)PPCCallOS(&MyCaos));
  883. }
  884.  
  885. #ifndef NO_PPCINLINE_STDARG
  886. #define PPCSetAttrsTags(tags...) \
  887.     ({ULONG _tags[] = { tags }; PPCSetAttrs((struct TagItem*)_tags);})
  888. #endif /* !NO_PPCINLINE_STDARG */
  889.  
  890. #define    PPCSetPortListAttr(PPCPortList, Attr)    _PPCSetPortListAttr(PPC_BASE_NAME, PPCPortList, Attr)
  891.  
  892. static __inline void
  893. _PPCSetPortListAttr(void *PPCLibBase, void*PPCPortList, ULONG Attr)
  894. {
  895. struct Caos    MyCaos;
  896.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  897. //    MyCaos.M68kStart    =    NULL;
  898. //    MyCaos.M68kSize        =    0;
  899.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  900. //    MyCaos.PPCStart        =    NULL;
  901. //    MyCaos.PPCSize        =    0;
  902.     MyCaos.a0        =(ULONG) PPCPortList;
  903.     MyCaos.d0        =(ULONG) Attr;
  904.     MyCaos.caos_Un.Offset    =    (-402);
  905.     MyCaos.a6        =(ULONG) PPCLibBase;    
  906.     PPCCallOS(&MyCaos);
  907. }
  908.  
  909. #define    PPCSetTaskAttrs(TaskObject, Tags)    _PPCSetTaskAttrs(PPC_BASE_NAME, TaskObject, Tags)
  910.  
  911. static __inline ULONG
  912. _PPCSetTaskAttrs(void *PPCLibBase, void*TaskObject, struct TagItem*Tags)
  913. {
  914. struct Caos    MyCaos;
  915.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  916. //    MyCaos.M68kStart    =    NULL;
  917. //    MyCaos.M68kSize        =    0;
  918.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  919. //    MyCaos.PPCStart        =    NULL;
  920. //    MyCaos.PPCSize        =    0;
  921.     MyCaos.a0        =(ULONG) TaskObject;
  922.     MyCaos.a1        =(ULONG) Tags;
  923.     MyCaos.caos_Un.Offset    =    (-192);
  924.     MyCaos.a6        =(ULONG) PPCLibBase;    
  925.     return((ULONG)PPCCallOS(&MyCaos));
  926. }
  927.  
  928. #ifndef NO_PPCINLINE_STDARG
  929. #define PPCSetTaskAttrsTags(a0, tags...) \
  930.     ({ULONG _tags[] = { tags }; PPCSetTaskAttrs((a0), (struct TagItem*)_tags);})
  931. #endif /* !NO_PPCINLINE_STDARG */
  932.  
  933. #define    PPCSignalTask(TaskObject, SignalMask)    _PPCSignalTask(PPC_BASE_NAME, TaskObject, SignalMask)
  934.  
  935. static __inline void
  936. _PPCSignalTask(void *PPCLibBase, void*TaskObject, ULONG SignalMask)
  937. {
  938. struct Caos    MyCaos;
  939.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  940. //    MyCaos.M68kStart    =    NULL;
  941. //    MyCaos.M68kSize        =    0;
  942.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  943. //    MyCaos.PPCStart        =    NULL;
  944. //    MyCaos.PPCSize        =    0;
  945.     MyCaos.a0        =(ULONG) TaskObject;
  946.     MyCaos.d0        =(ULONG) SignalMask;
  947.     MyCaos.caos_Un.Offset    =    (-96);
  948.     MyCaos.a6        =(ULONG) PPCLibBase;    
  949.     PPCCallOS(&MyCaos);
  950. }
  951.  
  952. #define    PPCStartTask(TaskObject, Tags)    _PPCStartTask(PPC_BASE_NAME, TaskObject, Tags)
  953.  
  954. static __inline BOOL
  955. _PPCStartTask(void *PPCLibBase, void*TaskObject, struct TagItem*Tags)
  956. {
  957. struct Caos    MyCaos;
  958.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  959. //    MyCaos.M68kStart    =    NULL;
  960. //    MyCaos.M68kSize        =    0;
  961.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  962. //    MyCaos.PPCStart        =    NULL;
  963. //    MyCaos.PPCSize        =    0;
  964.     MyCaos.a0        =(ULONG) TaskObject;
  965.     MyCaos.a1        =(ULONG) Tags;
  966.     MyCaos.caos_Un.Offset    =    (-180);
  967.     MyCaos.a6        =(ULONG) PPCLibBase;    
  968.     return((BOOL)PPCCallOS(&MyCaos));
  969. }
  970.  
  971. #ifndef NO_PPCINLINE_STDARG
  972. #define PPCStartTaskTags(a0, tags...) \
  973.     ({ULONG _tags[] = { tags }; PPCStartTask((a0), (struct TagItem*)_tags);})
  974. #endif /* !NO_PPCINLINE_STDARG */
  975.  
  976. #define    PPCStopTask(TaskObject, Tags)    _PPCStopTask(PPC_BASE_NAME, TaskObject, Tags)
  977.  
  978. static __inline BOOL
  979. _PPCStopTask(void *PPCLibBase, void*TaskObject, struct TagItem*Tags)
  980. {
  981. struct Caos    MyCaos;
  982.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  983. //    MyCaos.M68kStart    =    NULL;
  984. //    MyCaos.M68kSize        =    0;
  985.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  986. //    MyCaos.PPCStart        =    NULL;
  987. //    MyCaos.PPCSize        =    0;
  988.     MyCaos.a0        =(ULONG) TaskObject;
  989.     MyCaos.a1        =(ULONG) Tags;
  990.     MyCaos.caos_Un.Offset    =    (-186);
  991.     MyCaos.a6        =(ULONG) PPCLibBase;    
  992.     return((BOOL)PPCCallOS(&MyCaos));
  993. }
  994.  
  995. #ifndef NO_PPCINLINE_STDARG
  996. #define PPCStopTaskTags(a0, tags...) \
  997.     ({ULONG _tags[] = { tags }; PPCStopTask((a0), (struct TagItem*)_tags);})
  998. #endif /* !NO_PPCINLINE_STDARG */
  999.  
  1000. #define    PPCUnLoadObject(Object)    _PPCUnLoadObject(PPC_BASE_NAME, Object)
  1001.  
  1002. static __inline void
  1003. _PPCUnLoadObject(void *PPCLibBase, void*Object)
  1004. {
  1005. struct Caos    MyCaos;
  1006.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1007. //    MyCaos.M68kStart    =    NULL;
  1008. //    MyCaos.M68kSize        =    0;
  1009.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1010. //    MyCaos.PPCStart        =    NULL;
  1011. //    MyCaos.PPCSize        =    0;
  1012.     MyCaos.a0        =(ULONG) Object;
  1013.     MyCaos.caos_Un.Offset    =    (-36);
  1014.     MyCaos.a6        =(ULONG) PPCLibBase;    
  1015.     PPCCallOS(&MyCaos);
  1016. }
  1017.  
  1018. #define    PPCWaitPort(PPCPort)    _PPCWaitPort(PPC_BASE_NAME, PPCPort)
  1019.  
  1020. static __inline void*
  1021. _PPCWaitPort(void *PPCLibBase, void*PPCPort)
  1022. {
  1023. struct Caos    MyCaos;
  1024.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1025. //    MyCaos.M68kStart    =    NULL;
  1026. //    MyCaos.M68kSize        =    0;
  1027.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1028. //    MyCaos.PPCStart        =    NULL;
  1029. //    MyCaos.PPCSize        =    0;
  1030.     MyCaos.a0        =(ULONG) PPCPort;
  1031.     MyCaos.caos_Un.Offset    =    (-336);
  1032.     MyCaos.a6        =(ULONG) PPCLibBase;    
  1033.     return((void*)PPCCallOS(&MyCaos));
  1034. }
  1035.  
  1036. #define    PPCWaitPortList(PPCPortList)    _PPCWaitPortList(PPC_BASE_NAME, PPCPortList)
  1037.  
  1038. static __inline void*
  1039. _PPCWaitPortList(void *PPCLibBase, void*PPCPortList)
  1040. {
  1041. struct Caos    MyCaos;
  1042.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1043. //    MyCaos.M68kStart    =    NULL;
  1044. //    MyCaos.M68kSize        =    0;
  1045.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1046. //    MyCaos.PPCStart        =    NULL;
  1047. //    MyCaos.PPCSize        =    0;
  1048.     MyCaos.a0        =(ULONG) PPCPortList;
  1049.     MyCaos.caos_Un.Offset    =    (-390);
  1050.     MyCaos.a6        =(ULONG) PPCLibBase;    
  1051.     return((void*)PPCCallOS(&MyCaos));
  1052. }
  1053.  
  1054. #define    PPCWriteByte(Address, Value)    _PPCWriteByte(PPC_BASE_NAME, Address, Value)
  1055.  
  1056. static __inline void
  1057. _PPCWriteByte(void *PPCLibBase, UBYTE*Address, UBYTE Value)
  1058. {
  1059. struct Caos    MyCaos;
  1060.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1061. //    MyCaos.M68kStart    =    NULL;
  1062. //    MyCaos.M68kSize        =    0;
  1063.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1064. //    MyCaos.PPCStart        =    NULL;
  1065. //    MyCaos.PPCSize        =    0;
  1066.     MyCaos.a0        =(ULONG) Address;
  1067.     MyCaos.d0        =(ULONG) Value;
  1068.     MyCaos.caos_Un.Offset    =    (-228);
  1069.     MyCaos.a6        =(ULONG) PPCLibBase;    
  1070.     PPCCallOS(&MyCaos);
  1071. }
  1072.  
  1073. #define    PPCWriteLong(Address, Value)    _PPCWriteLong(PPC_BASE_NAME, Address, Value)
  1074.  
  1075. static __inline void
  1076. _PPCWriteLong(void *PPCLibBase, ULONG*Address, ULONG Value)
  1077. {
  1078. struct Caos    MyCaos;
  1079.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1080. //    MyCaos.M68kStart    =    NULL;
  1081. //    MyCaos.M68kSize        =    0;
  1082.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1083. //    MyCaos.PPCStart        =    NULL;
  1084. //    MyCaos.PPCSize        =    0;
  1085.     MyCaos.a0        =(ULONG) Address;
  1086.     MyCaos.d0        =(ULONG) Value;
  1087.     MyCaos.caos_Un.Offset    =    (-162);
  1088.     MyCaos.a6        =(ULONG) PPCLibBase;    
  1089.     PPCCallOS(&MyCaos);
  1090. }
  1091.  
  1092. #define    PPCWriteLongFlush(Address, Value)    _PPCWriteLongFlush(PPC_BASE_NAME, Address, Value)
  1093.  
  1094. static __inline void
  1095. _PPCWriteLongFlush(void *PPCLibBase, ULONG*Address, ULONG Value)
  1096. {
  1097. struct Caos    MyCaos;
  1098.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1099. //    MyCaos.M68kStart    =    NULL;
  1100. //    MyCaos.M68kSize        =    0;
  1101.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1102. //    MyCaos.PPCStart        =    NULL;
  1103. //    MyCaos.PPCSize        =    0;
  1104.     MyCaos.a0        =(ULONG) Address;
  1105.     MyCaos.d0        =(ULONG) Value;
  1106.     MyCaos.caos_Un.Offset    =    (-204);
  1107.     MyCaos.a6        =(ULONG) PPCLibBase;    
  1108.     PPCCallOS(&MyCaos);
  1109. }
  1110.  
  1111. #define    PPCWriteWord(Address, Value)    _PPCWriteWord(PPC_BASE_NAME, Address, Value)
  1112.  
  1113. static __inline void
  1114. _PPCWriteWord(void *PPCLibBase, UWORD*Address, UWORD Value)
  1115. {
  1116. struct Caos    MyCaos;
  1117.     MyCaos.M68kCacheMode    =    IF_CACHEFLUSHALL;
  1118. //    MyCaos.M68kStart    =    NULL;
  1119. //    MyCaos.M68kSize        =    0;
  1120.     MyCaos.PPCCacheMode    =    IF_CACHEFLUSHALL;
  1121. //    MyCaos.PPCStart        =    NULL;
  1122. //    MyCaos.PPCSize        =    0;
  1123.     MyCaos.a0        =(ULONG) Address;
  1124.     MyCaos.d0        =(ULONG) Value;
  1125.     MyCaos.caos_Un.Offset    =    (-216);
  1126.     MyCaos.a6        =(ULONG) PPCLibBase;    
  1127.     PPCCallOS(&MyCaos);
  1128. }
  1129.  
  1130. #endif /* SASC Pragmas */
  1131. #endif /* !_PPCPRAGMA_PPC_H */
  1132.